ATOM Documentation

from core.voice_command_processor import VoiceCommandProcessor

processor = VoiceCommandProcessor(db)
result = await processor.process_voice_command(
    tenant_id="tenant-123",
    agent_id="agent-456",
    command="Open dashboard",
    confidence=0.95
)

POST /api/voice/command
Content-Type: application/json
Authorization: Bearer <token>

{
  "command": "Execute sales report",
  "confidence": 0.92,
  "agent_id": "agent-456"
}

import { useVoiceCommands } from '@/lib/voice-commands';

function VoiceControl() {
  const { isListening, transcript, startListening, sendCommand } =
    useVoiceCommands('tenant-123');

  return (
    <>
      <button onClick={startListening}>Start Listening</button>
      {isListening && <p>Listening...</p>}
      {transcript && <p>You said: {transcript}</p>}
    </>
  );
}

import { VoiceFeedback } from '@/components/menu-bar/VoiceFeedback';

<VoiceFeedback
  isListening={true}
  transcript="Open dashboard"
  response="Opening dashboard now"
/>

// src-tauri/src/voice_wake_macos.rs
use cocoa::base::id;
use cocoa::foundation::NSString;

pub struct MacOSVoiceWake {
    recognizer: id, // SFSpeechRecognizer
    is_listening: bool,
}

impl MacOSVoiceWake {
    pub fn new(wake_word: &str) -> Self {
        // Initialize SFSpeechRecognizer
        // Request microphone permissions
        // Configure for continuous listening
        Self {
            recognizer: create_speech_recognizer(),
            is_listening: false,
        }
    }

    pub fn start_listening(&mut self) {
        // Start real-time speech recognition
        // Detect wake word in audio stream
    }
}

<!-- src-tauri/tauri.conf.json -->
<macOSPrivatePermissions>
  <key>microphone</key>
  <key>speech-recognition</key>
</macOSPrivatePermissions>

// src-tauri/src/voice_wake_windows.rs
use windows::Win32::Media::Speech::*;

pub struct WindowsVoiceWake {
    recognizer: ISpeechRecognizer,
}

impl WindowsVoiceWake {
    pub fn new(wake_word: &str) -> Self {
        // Initialize Windows Speech Platform
        Self {
            recognizer: create_speech_recognizer(),
        }
    }
}

// src-tauri/src/voice_wake_linux.rs
use pocketsphinx::*

pub struct LinuxVoiceWake {
    decoder: ps_decoder_t,
}

impl LinuxVoiceWake {
    pub fn new(wake_word: &str) -> Self {
        // Initialize Pocketsphinx
        // Load acoustic model
        Self {
            decoder: create_decoder(),
        }
    }
}

"Hey ATOM, execute reconcile inventory"
"ATOM, run the sales report"
"Send a summary email to John"

"Open my dashboard"
"Go to dashboard"
"Show me the dashboard"

"Check agent health"
"What's the status?"
"How are the agents doing?"

"Pause all agents"
"Enable autonomous mode"
"Show recent interventions"

const voiceConfig = {
  wakeWord: "Hey ATOM",
  sensitivity: 0.7,        // 0-1, higher = more sensitive
  language: "en-US",
  continuous: false,        // Stop after one command
  requireConfirmation: true  // Ask for confirmation on sensitive actions
};

const commandConfig = {
  confidenceThreshold: 0.7,  // Minimum confidence to process
  timeout: 5000,              // Command timeout (ms)
  maxRetries: 3,              // Maximum recognition retries
};

if (!client.isSupported()) {
  showNotification(
    "Voice commands not supported in this browser",
    "error"
  );
}

if (confidence < 0.7) {
  return {
    success: false,
    message: "I didn't catch that. Could you repeat?",
    requires_confirmation: true
  };
}

navigator.mediaDevices.getUserMedia({ audio: true })
  .catch(err => {
    showNotification(
      "Microphone access denied. Please enable in browser settings.",
      "error"
    );
  });

// Test voice command classification
describe('Voice Command Processor', () => {
  it('should classify dashboard command', async () => {
    const result = await processor.process_voice_command(
      tenant_id,
      agent_id,
      "Open dashboard",
      0.95
    );
    expect(result.action).toBe('open_url');
  });

  it('should reject low confidence commands', async () => {
    const result = await processor.process_voice_command(
      tenant_id,
      agent_id,
      "Mumble mumble",
      0.5
    );
    expect(result.success).toBe(false);
  });
});